package com.svs.system.service;

import java.util.ArrayList;
import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import com.svs.common.annotation.DataScope;
import com.svs.common.constant.UserConstants;
import com.svs.common.support.Convert;
import com.svs.common.utils.StringUtils;
import com.svs.framework.base.service.CrudService;
import com.svs.system.domain.SysPost;
import com.svs.system.domain.SysRole;
import com.svs.system.domain.SysUser;
import com.svs.system.domain.SysUserPost;
import com.svs.system.domain.SysUserRole;
import com.svs.system.mapper.master.SysPostDao;
import com.svs.system.mapper.master.SysRoleDao;
import com.svs.system.mapper.master.SysUserDao;
import com.svs.system.mapper.master.SysUserPostDao;
import com.svs.system.mapper.master.SysUserRoleDao;

/**
 * 用户 业务层处理
 * 
 * @author dujianqiao
 */
@Service
public class SysUserService extends CrudService<SysUserDao, SysUser> {
	@Autowired
	private SysUserDao userMapper;

	@Autowired
	private SysRoleDao roleMapper;

	@Autowired
	private SysPostDao postMapper;

	@Autowired
	private SysUserPostDao userPostMapper;

	@Autowired
	private SysUserRoleDao userRoleMapper;

	/**
	 * 根据条件分页查询用户对象
	 * 
	 * @param user
	 *            用户信息
	 * 
	 * @return 用户信息集合信息
	 */
	@Override
    @DataScope(tableAlias = "u")
	public List<SysUser> selectAllList(SysUser user) {
		return userMapper.selectAllList(user);
	}
	
	public List<SysUser> selectUserByRoleId(SysUser user) {
		return userMapper.selectUserByRoleId(user);
	}

	/**
	 * 通过用户名查询用户
	 * 
	 * @param userName
	 *            用户名
	 * @return 用户对象信息
	 */
	public SysUser selectUserByLoginName(String userName) {
		return userMapper.selectUserByLoginName(userName);
	}

	/**
	 * 通过手机号码查询用户
	 * 
	 * @param userName
	 *            用户名
	 * @return 用户对象信息
	 */
	public SysUser selectUserByPhoneNumber(String phoneNumber) {
		return userMapper.selectUserByPhoneNumber(phoneNumber);
	}

	/**
	 * 通过邮箱查询用户
	 * 
	 * @param email
	 *            邮箱
	 * @return 用户对象信息
	 */
	public SysUser selectUserByEmail(String email) {
		return userMapper.selectUserByEmail(email);
	}


	/**
	 * 通过用户ID删除用户
	 * 
	 * @param userId
	 *            用户ID
	 * @return 结果
	 */
	public int deleteUserById(Long userId) {
		// 删除用户与角色关联
		userRoleMapper.deleteUserRoleByUserId(userId);
		// 删除用户与岗位表
		userPostMapper.deleteUserPostByUserId(userId);
		return userMapper.deleteByPrimaryKey(userId);
	}

	/**
	 * 批量删除用户信息
	 * 
	 * @param ids
	 *            需要删除的数据ID
	 * @return 结果
	 */
	public int deleteUserByIds(String ids) throws Exception {
		Long[] userIds = Convert.toLongArray(ids);
		for (Long userId : userIds) {
			if (SysUser.isAdmin(userId)) {
				throw new Exception("不允许删除超级管理员用户");
			}
		}
		String[] uIds = Convert.toStrArray(ids) ;
		return userMapper.deleteByPrimaryKeys(uIds);
	}

	/**
	 * 新增保存用户信息
	 * 
	 * @param user
	 *            用户信息
	 * @return 结果
	 */
	public int insertSelective(SysUser user) {
		// 新增用户信息
		int rows = userMapper.insertSelective(user);
		// 新增用户岗位关联
		insertUserPost(user);
		// 新增用户与角色管理
		insertUserRole(user);
		return rows;
	}

	/**
	 * 修改保存用户信息
	 * 
	 * @param user
	 *            用户信息
	 * @return 结果
	 */
	public int updateByPrimaryKeySelective(SysUser user) {
		Long userId = user.getUserId();
		// 删除用户与角色关联
		userRoleMapper.deleteUserRoleByUserId(userId);
		// 新增用户与角色管理
		insertUserRole(user);
		// 删除用户与岗位关联
		userPostMapper.deleteUserPostByUserId(userId);
		// 新增用户与岗位管理
		insertUserPost(user);
		return userMapper.updateByPrimaryKeySelective(user);
	}
	
	
	/**
	 * 修改保存用户信息
	 * 
	 * @param user
	 *            用户信息
	 * @return 结果
	 */
	public int update4QyId(SysUser user) {
		SysUser update = new SysUser();
		update.setUserId(user.getUserId());
		update.setQyId(user.getQyId());
		update.setArea(user.getArea());
		update.setAreaCode(user.getAreaCode());
		update.setCity(user.getCity());
		update.setCityCode(user.getCityCode());
		update.setProvince(user.getProvince());
		update.setProvinceCode(user.getProvinceCode());
		return userMapper.updateByPrimaryKeySelective(update);
	}


	/**
	 * 修改用户密码
	 * 
	 * @param user
	 *            用户信息
	 * @return 结果
	 */
	public int resetUserPwd(SysUser user) {
		return update(user);
	}

	/**
	 * 新增用户角色信息
	 * 
	 * @param user
	 *            用户对象
	 */
	public void insertUserRole(SysUser user) {
		// 新增用户与角色管理
		List<SysUserRole> list = new ArrayList<SysUserRole>();
		if(null!=user.getRoleIds()){
			for (Long roleId : user.getRoleIds()) {
				SysUserRole ur = new SysUserRole();
				ur.setUserId(user.getUserId());
				ur.setRoleId(roleId);
				list.add(ur);
			}			
		}
		if (list.size() > 0) {
			userRoleMapper.batchUserRole(list);
		}
	}

	/**
	 * 新增用户岗位信息
	 * 
	 * @param user
	 *            用户对象
	 */
	public void insertUserPost(SysUser user) {
		// 新增用户与岗位管理
		List<SysUserPost> list = new ArrayList<SysUserPost>();
		if(null!=user.getPostIds()){
			for (Long postId : user.getPostIds()) {
				SysUserPost up = new SysUserPost();
				up.setUserId(user.getUserId());
				up.setPostId(postId);
				list.add(up);
			}
		}
		if (list.size() > 0) {
			userPostMapper.batchUserPost(list);
		}
	}

	/**
	 * 校验用户名称是否唯一
	 * 
	 * @param loginName
	 *            用户名
	 * @return
	 */
	public String checkLoginNameUnique(String loginName) {
		int count = userMapper.checkLoginNameUnique(loginName);
		if (count > 0) {
			return UserConstants.USER_NAME_NOT_UNIQUE;
		}
		return UserConstants.USER_NAME_UNIQUE;
	}

	/**
	 * 校验用户名称是否唯一
	 *
	 * @param phonenumber
	 *            用户名
	 * @return
	 */
	public String checkPhoneUnique(SysUser user) {
		Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
		SysUser info = userMapper.checkPhoneUnique(user.getPhonenumber());
		if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
			return UserConstants.USER_PHONE_NOT_UNIQUE;
		}
		return UserConstants.USER_PHONE_UNIQUE;
	}

	/**
	 * 校验email是否唯一
	 *
	 * @param email
	 *            用户名
	 * @return
	 */
	public String checkEmailUnique(SysUser user) {
		Long userId = StringUtils.isNull(user.getUserId()) ? -1L : user.getUserId();
		SysUser info = userMapper.checkEmailUnique(user.getEmail());
		if (StringUtils.isNotNull(info) && info.getUserId().longValue() != userId.longValue()) {
			return UserConstants.USER_EMAIL_NOT_UNIQUE;
		}
		return UserConstants.USER_EMAIL_UNIQUE;
	}

	/**
	 * 查询用户所属角色组
	 * 
	 * @param userId
	 *            用户ID
	 * @return 结果
	 */
	public String selectUserRoleGroup(Long userId) {
		List<SysRole> list = roleMapper.selectRolesByUserId(userId);
		StringBuffer idsStr = new StringBuffer();
		for (SysRole role : list) {
			idsStr.append(role.getRoleName()).append(",");
		}
		if (StringUtils.isNotEmpty(idsStr.toString())) {
			return idsStr.substring(0, idsStr.length() - 1);
		}
		return idsStr.toString();
	}

	/**
	 * 查询用户所属岗位组
	 * 
	 * @param userId
	 *            用户ID
	 * @return 结果
	 */
	public String selectUserPostGroup(Long userId) {
		List<SysPost> list = postMapper.selectPostsByUserId(userId);
		StringBuffer idsStr = new StringBuffer();
		for (SysPost post : list) {
			idsStr.append(post.getPostName()).append(",");
		}
		if (StringUtils.isNotEmpty(idsStr.toString())) {
			return idsStr.substring(0, idsStr.length() - 1);
		}
		return idsStr.toString();
	}
	
	public SysUser queryUserCount(SysUser user){
		return userMapper.selectUserCount(user);
	}
	
}
